.TH std::set 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::set \- std::set

.SH Synopsis
   Defined in header <set>
   template<

       class Key,
       class Compare = std::less<Key>,                                \fB(1)\fP
       class Allocator = std::allocator<Key>

   > class set;
   namespace pmr {

       template<
           class Key,
           class Compare = std::less<Key>                             \fB(2)\fP \fI(since C++17)\fP
       > using set = std::set<Key, Compare,
   std::pmr::polymorphic_allocator<Key>>;

   }

   std::set is an associative container that contains a sorted set of unique objects of
   type Key. Sorting is done using the key comparison function Compare. Search,
   removal, and insertion operations have logarithmic complexity. Sets are usually
   implemented as Red–black trees.

   Everywhere the standard library uses the Compare requirements, uniqueness is
   determined by using the equivalence relation. In imprecise terms, two objects a and
   b are considered equivalent if neither compares less than the other: !comp(a, b) &&
   !comp(b, a).

   std::set meets the requirements of Container, AllocatorAwareContainer,
   AssociativeContainer and ReversibleContainer.

.SH Template parameters

    This section is incomplete
    Reason: Add descriptions of the template parameters.

.SH Member types

   Member type               Definition
   key_type                  Key
   value_type                Key
   size_type                 Unsigned integer type (usually std::size_t)
   difference_type           Signed integer type (usually std::ptrdiff_t)
   key_compare               Compare
   value_compare             Compare
   allocator_type            Allocator
   reference                 value_type&
   const_reference           const value_type&
                             Allocator::pointer                        \fI(until C++11)\fP
   pointer                   std::allocator_traits<Allocator>::pointer \fI(since C++11)\fP


                             Allocator::const_pointer                        (until
                                                                             C++11)
   const_pointer             std::allocator_traits<Allocator>::const_pointer (since
                                                                             C++11)


   iterator                  Constant LegacyBidirectionalIterator to value_type
   const_iterator            LegacyBidirectionalIterator to const value_type
   reverse_iterator          std::reverse_iterator<iterator>
   const_reverse_iterator    std::reverse_iterator<const_iterator>
   node_type \fI(since C++17)\fP   a specialization of node handle representing a container
                             node
                             type describing the result of inserting a node_type, a
                             specialization of

                             template<class Iter, class NodeType>
                             struct /*unspecified*/
   insert_return_type (since {
   C++17)                        Iter     position;
                                 bool     inserted;
                                 NodeType node;
                             };
                             instantiated with template arguments iterator and
                             node_type.

.SH Member functions

   constructor   constructs the set
                 \fI(public member function)\fP
   destructor    destructs the set
                 \fI(public member function)\fP
   operator=     assigns values to the container
                 \fI(public member function)\fP
   get_allocator returns the associated allocator
                 \fI(public member function)\fP
.SH Iterators
   begin         returns an iterator to the beginning
   cbegin        \fI(public member function)\fP
   \fI(C++11)\fP
   end           returns an iterator to the end
   cend          \fI(public member function)\fP
   \fI(C++11)\fP
   rbegin        returns a reverse iterator to the beginning
   crbegin       \fI(public member function)\fP
   \fI(C++11)\fP
   rend          returns a reverse iterator to the end
   crend         \fI(public member function)\fP
   \fI(C++11)\fP
.SH Capacity
   empty         checks whether the container is empty
                 \fI(public member function)\fP
   size          returns the number of elements
                 \fI(public member function)\fP
   max_size      returns the maximum possible number of elements
                 \fI(public member function)\fP
.SH Modifiers
   clear         clears the contents
                 \fI(public member function)\fP
                 inserts elements
   insert        or nodes
                 \fI(since C++17)\fP
                 \fI(public member function)\fP
   insert_range  inserts a range of elements
   (C++23)       \fI(public member function)\fP
   emplace       constructs element in-place
   \fI(C++11)\fP       \fI(public member function)\fP
   emplace_hint  constructs elements in-place using a hint
   \fI(C++11)\fP       \fI(public member function)\fP
   erase         erases elements
                 \fI(public member function)\fP
   swap          swaps the contents
                 \fI(public member function)\fP
   extract       extracts nodes from the container
   \fI(C++17)\fP       \fI(public member function)\fP
   merge         splices nodes from another container
   \fI(C++17)\fP       \fI(public member function)\fP
.SH Lookup
   count         returns the number of elements matching specific key
                 \fI(public member function)\fP
   find          finds element with specific key
                 \fI(public member function)\fP
   contains      checks if the container contains element with specific key
   (C++20)       \fI(public member function)\fP
   equal_range   returns range of elements matching a specific key
                 \fI(public member function)\fP
   lower_bound   returns an iterator to the first element not less than the given key
                 \fI(public member function)\fP
   upper_bound   returns an iterator to the first element greater than the given key
                 \fI(public member function)\fP
.SH Observers
   key_comp      returns the function that compares keys
                 \fI(public member function)\fP
   value_comp    returns the function that compares keys in objects of type value_type
                 \fI(public member function)\fP

.SH Non-member functions

   operator==
   operator!=
   operator<
   operator<=
   operator>
   operator>=          lexicographically compares the values of two sets
   operator<=>         \fI(function template)\fP
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (C++20)
   std::swap(std::set) specializes the std::swap algorithm
                       \fI(function template)\fP
   erase_if(std::set)  erases all elements satisfying specific criteria
   (C++20)             \fI(function template)\fP

     Deduction guides \fI(since C++17)\fP

.SH Notes

   The member types iterator and const_iterator may be aliases to the same type. This
   means defining a pair of function overloads using the two types as parameter types
   may violate the One Definition Rule. Since iterator is convertible to
   const_iterator, a single function with a const_iterator as parameter type will work
   instead.

       Feature-test macro       Value    Std                   Feature
   __cpp_lib_containers_ranges 202202L (C++23) Ranges construction and insertion for
                                               containers

.SH Example

    This section is incomplete
    Reason: no example

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to           Behavior as published              Correct behavior
   LWG 103 C++98      iterator allows modification of keys      iterator made constant
                      Key was not required to be
   LWG 230 C++98      CopyConstructible                         Key is also required to
                      (a key of type Key might not be able to   be CopyConstructible
                      be constructed)

.SH Categories:
     * Todo with reason
     * Todo no example
